Computer Active Guide 2009 September/CAG09.ISO/Programos/systemtweaker.exe/{app}/library.dat/decorator.pyo

Python Compiled Bytecode | 2010-11-12 | 6.5 KB | 196 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.6)

__all__ = [
    'decorator',
    'FunctionMaker',
    'partial',
    'deprecated',
    'getinfo',
    'new_wrapper']
import os
import sys
import re
import inspect
import string
import warnings

try:
    from functools import partial
except ImportError:

    class partial(object):

        def __init__(self, func, *args, **kw):
            self.func = func
            self.args = args
            self.keywords = kw


        def __call__(self, *otherargs, **otherkw):
            kw = self.keywords.copy()
            kw.update(otherkw)
            return self.func(*self.args + otherargs, **kw)



DEF = re.compile('\\s*def\\s*([_\\w][_\\w\\d]*)\\s*\\(')

class FunctionMaker(object):

    def __init__(self, func = None, name = None, signature = None, defaults = None, doc = None, module = None, funcdict = None):
        if func:
            self.name = func.__name__
            if self.name == '<lambda>':
                self.name = '_lambda_'

            self.doc = func.__doc__
            self.module = func.__module__
            if inspect.isfunction(func):
                argspec = inspect.getargspec(func)
                (self.args, self.varargs, self.keywords, self.defaults) = argspec
                for i, arg in enumerate(self.args):
                    setattr(self, 'arg%d' % i, arg)

                self.signature = inspect.formatargspec(formatvalue = (lambda val: ''), *argspec)[1:-1]
                self.dict = func.__dict__.copy()


        if name:
            self.name = name

        if signature is not None:
            self.signature = signature

        if defaults:
            self.defaults = defaults

        if doc:
            self.doc = doc

        if module:
            self.module = module

        if funcdict:
            self.dict = funcdict

        if not hasattr(self, 'signature'):
            raise TypeError('You are decorating a non function: %s' % func)
        hasattr(self, 'signature')


    def update(self, func, **kw):
        func.__name__ = self.name
        func.__doc__ = getattr(self, 'doc', None)
        func.__dict__ = getattr(self, 'dict', { })
        func.func_defaults = getattr(self, 'defaults', ())
        callermodule = sys._getframe(3).f_globals.get('__name__', '?')
        func.__module__ = getattr(self, 'module', callermodule)
        func.__dict__.update(kw)


    def make(self, src_templ, evaldict = None, addsource = False, **attrs):
        src = src_templ % vars(self)
        if not evaldict:
            pass
        evaldict = { }
        mo = DEF.match(src)
        if mo is None:
            raise SyntaxError('not a valid function template\n%s' % src)
        mo is None
        name = mo.group(1)
        reserved_names = []([] + [ arg.strip(' *') for arg in self.signature.split(',') ])
        for n, v in evaldict.iteritems():
            if n in reserved_names:
                raise NameError('%s is overridden in\n%s' % (n, src))
            n in reserved_names


        try:
            code = compile(src, '<string>', 'single')
            exec code in evaldict
        except:
            None if not src.endswith('\n') else set
            print >>sys.stderr, 'Error in generated code:'
            print >>sys.stderr, src
            raise

        func = evaldict[name]
        if addsource:
            attrs['__source__'] = src

        self.update(func, **attrs)
        return func


    def create(cls, obj, body, evaldict, defaults = None, doc = None, module = None, addsource = True, **attrs):
        if isinstance(obj, str):
            (name, rest) = obj.strip().split('(', 1)
            signature = rest[:-1]
            func = None
        else:
            name = None
            signature = None
            func = obj
        fun = cls(func, name, signature, defaults, doc, module)
        ibody = '\n'.join((lambda .0: for line in .0:
'    ' + line)(body.splitlines()))
        return fun.make('def %(name)s(%(signature)s):\n' + ibody, evaldict, addsource, **attrs)

    create = classmethod(create)


def decorator(caller, func = None):
    if func is not None:
        return FunctionMaker.create(func, 'return _call_(_func_, %(signature)s)', dict(_call_ = caller, _func_ = func), undecorated = func)
    if isinstance(caller, partial):
        return partial(decorator, caller)
    f = inspect.getargspec(caller)[0][0]
    return FunctionMaker.create('%s(%s)' % (caller.__name__, f), 'return decorator(_call_, %s)' % f, dict(_call_ = caller, decorator = decorator), undecorated = caller, doc = caller.__doc__, module = caller.__module__)


def deprecated(func, *args, **kw):
    warnings.warn('Calling the deprecated function %r\nDowngrade to decorator 2.3 if you want to use this functionality' % func.__name__, DeprecationWarning, stacklevel = 3)
    return func(*args, **kw)

deprecated = decorator(deprecated)

def getinfo(func):
    (regargs, varargs, varkwargs, defaults) = inspect.getargspec(func)
    argnames = list(regargs)
    if varargs:
        argnames.append(varargs)

    if varkwargs:
        argnames.append(varkwargs)

    signature = inspect.formatargspec(regargs, varargs, varkwargs, defaults, formatvalue = (lambda value: ''))[1:-1]
    return dict(name = func.__name__, argnames = argnames, signature = signature, defaults = func.func_defaults, doc = func.__doc__, module = func.__module__, dict = func.__dict__, globals = func.func_globals, closure = func.func_closure)

getinfo = deprecated(getinfo)

def update_wrapper(wrapper, model, infodict = None):
    if not infodict:
        pass
    infodict = getinfo(model)
    wrapper.__name__ = infodict['name']
    wrapper.__doc__ = infodict['doc']
    wrapper.__module__ = infodict['module']
    wrapper.__dict__.update(infodict['dict'])
    wrapper.func_defaults = infodict['defaults']
    wrapper.undecorated = model
    return wrapper

update_wrapper = deprecated(update_wrapper)

def new_wrapper(wrapper, model):
    if isinstance(model, dict):
        infodict = model
    else:
        infodict = getinfo(model)
    src = 'lambda %(signature)s: _wrapper_(%(signature)s)' % infodict
    funcopy = eval(src, dict(_wrapper_ = wrapper))
    return update_wrapper(funcopy, model, infodict)

new_wrapper = deprecated(new_wrapper)